﻿#define _CRT_SECURE_NO_WARNINGS

//#include<stdio.h>
//
//int main()
//{
//	printf("hello world\n");
//	return 0;
//}

//#include<iostream>
//using namespace std;
//
//int main()
//{
//	cout << "hello world" << endl;
//	return 0;
//}


//#include<stdio.h>
//#include<stdlib.h>
//
//namespace ganyu
//{
//	int rand = 10;
//}
//
//int main()
//{
//	printf("%d\n", ganyu::rand);
//	return 0;
//}


//#include<stdio.h>
//namespace ganyu
//{
//	namespace cw
//	{
//		struct Node
//		{
//			int val;
//			struct Node* next;
//		};
//	}
//
//	namespace cq
//	{
//		int Add(int x, int y)
//		{
//			return x + y;
//		}
//	}
//}

//int main()
//{
//	struct ganyu::cw::Node newnode = { 0 };
//	ganyu::cq::Add(10, 20);
//	return 0;
//}



// 多⽂件中可以定义同名namespace，他们会默认合并到⼀起，就像同⼀个namespace⼀样
// Stack.h
//#pragma once
//#include<stdio.h>
//#include<stdlib.h>
//#include<stdbool.h>
//#include<assert.h>
//namespace ganyu
//{
//	typedef int STDataType;
//	typedef struct Stack
//	{
//		STDataType * a;
//		int top;
//		int capacity;
//	}ST;
//	void STInit(ST* ps, int n);
//	void STDestroy(ST* ps);
//	void STPush(ST* ps, STDataType x);
//	void STPop(ST* ps);
//	STDataType STTop(ST* ps);
//	int STSize(ST* ps);
//	bool STEmpty(ST* ps);
//}



//// test.cpp
//#include"Stack.h"
//// 全局定义了⼀份单独的Stack
//typedef struct Stack
//{
//	int a[10];
//	int top;
//}ST;
//void STInit(ST* ps) {}
//void STPush(ST* ps, int x) {}
//int main()
//{
//	// 调⽤全局的
//	ST st1;
//	STInit(&st1);
//	STPush(&st1, 1);
//	STPush(&st1, 2);
//	printf("%d\n", sizeof(st1));
//	// 调⽤ganyu namespace的
//	ganyu::ST st2;
//	printf("%d\n", sizeof(st2));
//	ganyu::STInit(&st2);
//	ganyu::STPush(&st2, 1);
//	ganyu::STPush(&st2, 2);
//	return 0;
//}


//#include<stdio.h>
//
//namespace ganyu
//{
//	int a = 0;
//	int b = 1;
//}

// 展开命名空间中全部成员
//using namespace ganyu;
//int main()
//{
//	printf("%d\n", a);
//	printf("%d\n", b);
//	return 0;
//}


//#include<stdio.h>
//namespace bit
//{
//	int a = 0;
//	int b = 1;
//}
//
//using N::b;
//int main()
//{
//	printf("%d\n", N::a);
//	printf("%d\n", b);
//	return 0;
//}


//#include<iostream>
//using namespace std;
//
//int main()
//{
//	int a = 10;
//	float b = 2.5f;
//	char c = 't';
//
//	std::cout << a << " " << b << " " << c << std::endl;
//
//	std::cout << a" "  <<  std::endl;
//
//	printf("%d %f %c\n", a, b, c);
//	return 0;
//}


//#include<iostream>
//using namespace std;
//
//int main()
//{
//	int a = 0;
//	float b = 0.0f;
//	char c = 0;
//	cin >> a >> b >> c;
//	cout << a << "\n" << b << '\n' << c << endl;
//	return 0;
//}


//#include<iostream>
//int main()
//{
//	double a = 2.222222;
//	printf("%.2lf\n", a);
//	return 0;
//}


//ios_base::sync_with_stdio(false);
//cin.tie(nullptr);
//cout.tie(nullptr);


//#include <iostream>
//using namespace std;
//
//void Func(int a = 0)
//{
//	cout << a << endl;
//}

//int main()
//{
//	Func(); // 没有传参时，使⽤参数的默认值
//	Func(10); // 传参时，使⽤指定的实参
//	return 0;
//}


//void Func1(int a = 10, int b = 20, int c = 30)
//{
//	cout << "a = " << a << endl;
//	cout << "b = " << b << endl;
//	cout << "c = " << c << endl;
//}


//void Func2(int a, int b = 10, int c = 20)
//{
//	cout << "a = " << a << endl;
//	cout << "b = " << b << endl;
//	cout << "c = " << c << endl << endl;
//}



//#include <iostream>
//#include <assert.h>
//using namespace std;
//typedef int STDataType;
//typedef struct Stack
//{
//	STDataType* a;
//	int top;
//	int capacity;
//}ST;
//void STInit(ST* ps, int n = 4);
//
//
//
//#include"Stack.h"
//// 缺省参数不能声明和定义同时给
//void STInit(ST* ps, int n)
//{
//	assert(ps && n > 0);
//	ps->a = (STDataType*)malloc(n * sizeof(STDataType));
//	ps->top = 0;
//	ps->capacity = n;
//}


// 1、参数类型不同
//int Add(int left, int right)
//{
//	cout << "int Add(int left, int right)" << endl;
//	return left + right;
//} 
//double Add(double left, double right)
//{
//	cout << "double Add(double left, double right)" << endl;
//	return left + right;
//}
//
//
//void f()
//{
//	cout << "f()" << endl;
//} 
//void f(int a)
//{
//	cout << "f(int a)" << endl;
//}
//
//
//void f(int a, char b)
//{
//	cout << "f(int a,char b)" << endl;
//} 
//void f(char b, int a)
//{
//	cout << "f(char b, int a)" << endl;
//}


//void f1()
//{
//	cout << "f()" << endl;
//} 
//void f1(int a = 10)
//{
//	cout << "f(int a)" << endl;
//}


//#include<iostream>
//using namespace std;
//int main()
//{
//	int a = 0;
//	// 引⽤：b和c是a的别名
//	int& b = a;
//	int& c = a;
//	// 也可以给别名b取别名，d相当于还是a的别名
//	int& d = b;
//	++d;
//
//
//	cout << &a << endl;
//	cout << &b << endl;
//	cout << &c << endl;
//	cout << &d << endl;
//	return 0;
//}

//
//#include<iostream>
//using namespace std;

//void swap(int& rx, int& ry)
//{
//	int temp = rx;
//	rx = ry;
//	ry = temp;
//}

//int main()
//{
//	int a = 10;
//	int b = 20;
//	swap(a, b);
//	cout << "a = " << a << endl << "b = " << b << endl;
//	return 0;
//}

//int main()
//{
//	int a = 10;
//	int& b;
//	return 0;
//}



//typedef struct ListNode
//{
//	int val;
//	struct ListNode* next;
//}LTNode, * PNode;
// 指针变量也可以取别名，这⾥LTNode*& phead就是给指针变量取别名
// 这样就不需要⽤⼆级指针了，相对⽽⾔简化了程序
//void ListPushBack(LTNode** phead, int x)
//void ListPushBack(LTNode*& phead, int x)
//void ListPushBack(PNode& phead, int x)
//{
//	PNode newnode = (PNode)malloc(sizeof(LTNode));
//	newnode->val = x;
//	newnode->next = NULL;
//	if (phead == NULL)
//	{
//		phead = newnode;
//	} 
//	else
//	{
//		//...
//	}
//}

//#include<iostream>
//#include<assert.h>
//using namespace std;
//typedef int STDataType;
//typedef struct Stack
//{
//	STDataType* a;
//	int top;
//	int capacity;
//}ST;
//void STInit(ST& rs, int n = 4)
//{
//	rs.a = (STDataType*)malloc(n * sizeof(STDataType));
//	rs.top = 0;
//	rs.capacity = n;
//}
//
//int& STModityTop(ST& rs)
//{
//	assert(rs.top);
//	return rs.a[rs.top - 1];
//}
//
//
//void STPush(ST& rs, STDataType x)
//{
//
//	// 满了， 扩容
//	if (rs.top == rs.capacity)
//	{
//		printf("扩容\n");
//		int newcapacity = rs.capacity == 0 ? 4 : rs.capacity * 2;
//		STDataType* tmp = (STDataType*)realloc(rs.a, newcapacity *
//			sizeof(STDataType));
//		if (tmp == NULL)
//		{
//			perror("realloc fail");
//			return;
//		}
//		rs.a = tmp;
//		rs.capacity = newcapacity;
//	} 
//		rs.a[rs.top] = x;
//	rs.top++;
//}
//
//int main()
//{
//	ST st;
//	STInit(st);//初始化栈
//	STPush(st, 1);//插入数据
//
//	//修改栈顶元素
//	STModityTop(st) = 3;
//	return 0;
//}
//
//
//int& func()
//{
//	int a = 0;
//	return a;
//}


//#include<iostream>
//using namespace std;

//int main()
//{
//	const int& ra = 30;
//	return 0;
//}

//int main()
//{
//	double a = 3.6;
//	const int& ra = a;
//	return 0;
//}


//int main()
//{
//	int a = 0;
//
//	int* p = &a;
//	*p = 10;
//
//	int& ra = a;
//	ra = 20;
//
//	return 0;
//}
//
//#define ADD(x, y) ((x) + (y))
//
//inline int Add(int a, int b)
//{
//	return a + b;
//}
//int main()
//{
//	int a = 10;
//	int b = 20;
//	Add(a, b);
//	return 0;
//}


#ifndef NULL
	#ifdef __cplusplus
		#define NULL 0
	#else
		#define NULL ((void *)0)
	#endif
#endif


#include<iostream>
using namespace std;
void f(int x)
{
	cout << "f(int x)" << endl;
} 
void f(int* ptr)
{
	cout << "f(int* ptr)" << endl;
} 
//int main()
//{
//	f(0);
//	f(NULL);
//	f((void*)0);
//
//	return 0;
//}

int main()
{
	f(nullptr);
	return 0;
}
